OpenCV (Open Source Computer Vision Library: http://www.opencv.org) é uma biblioteca (ou conjunto de bibliotecas) disponível para algumas linguagens de programação que visa oferecer um vasto ferramental para tratamento de imagens, visão computacional e reconhecimento de padrões.

A biblioteca é organizada na forma de módulos, cada um agregando um conjunto de funções. Entre os módulos disponíveis pela biblioteca, destacam-se:

Neste tutorial, alguns desses módulos serão explorados na forma de exemplos e exercícios de fixação.

Detalhes acerca da instalação da biblioteca OpenCV não são descritos aqui. Cada sistema operacional possui uma forma de instalação distinta, que pode ser consultatada no quickstart oferecido no website do projeto.

O primeiro exemplo que será apresentado visa mostrar como compilar e executar um pequeno usando OpenCV em um ambiente Linux. Em suma, será necessário o arquivo contendo o código-fonte a ser compilado e um arquivo contendo regras de compilação na forma de um Makefile.

As tarefas de compilação foram automatizadas com o utilitário make. O make determina automaticamente que partes de um grande programa necessitam ser recompiladas e os comandos necessários para recompilá-las, a partir da leitura das regras definidas em um arquivo Makefile. Assim, para efetuar a compilação do programa, basta executar o comando make, ao invés de digitar dezenas de comandos no prompt do Unix.

O arquivo da Listagem 1 da foi utilizado para compilar os exemplos desse curso. Para obter uma cópia deste arquivo clique aqui. Veja que o arquivo utilizado prevê o uso da biblioteca opencv 4.0. Caso esteja utilizando alguma biblioteca mais antiga, subsititua o parâmetro opencv4 por apenas opencv e repita a compilação

As regras contidas neste arquivo Makefile incluem opções de compilação para incluir as dependências da biblioteca OpenCV para o programa que será compilado. Este Makefile possibilita que programas simples possam ser facilmente compilados. Como foi testado em um sistema Linux, o arquivo poderá carecer de modificações em outros sistemas.

O seu ambiente de desenvolvimento poderá ser testado com programa exemplos/hello.cpp , mostrada Listagem Hello, cuja única funcionalidade apresentar na tela uma imagem fornecida via linha de comando.

Para compilar e executar o programa hello.cpp, salve-o juntamente com o arquivo Makefile e a imagem biel.png em um diretório e execute a seguinte seqüência de comandos:

A saída do programa hello é mostrado na Figura 1

Caso o programa funcione conforme o exemplo, provavelmente seu ambiente de testes estará operacional para os exemplos do tutorial.

Neste tutorial, geralmente imagens armazenada no formato PNG serão usadas. Este formato suporta representação de imagens de diversas formas, como em tons de cinza, coloridas e preto-e-branco. Imagens em outros formatos tais como JPEG podem oferecer algumas limitações para os casos que serão abordados. Por exemplo, arquivos JPEG armazenam apenas imagens em formato colorido e, durante a o processo de gravação das imagens, o algoritmo de compressão com perdas pode modificar o conteúdo da imagem original a ser gravada.

Em geral, a maior parte das funcionalidades da biblioteca é definida no arquivo de cabeçalho opencv.hpp. É necessário procurar na árvore do compilador usado este arquivo para que seu caminho seja incluído no código.

Nesse arquivo, são definidos tipos básicos da biblioteca, bem como os protótipos de várias funções usadas para tratamento de imagens. Ele agrega as definições de funções que são usadas para entrada e saída de dados, criação de e manipulação de janelas e seus eventos, além de widgets para permitir interação com o usuário.

A interface em C++ do OpenCV provê um tipo básico de estrutura para armazenar imagems: a classe Mat. Dependendo da forma como é criado, um objeto dessa classe é capaz de armazenar imagens (matrizes) de diversos tipos diferentes, tais como inteiros, floats, doubles, etc.

Dezenas de métodos são providos para essa classe, métodos estes que serão apresentados ao longo do tutorial, conforme a demanda se dê. Nesta lição, apenas o método at será utilizado.

Outros tipos também são predefinidos no OpenCV, tal como o tipo Vec3b. A classe Vec é definida no OpenCV para abrigar diversas formas de vetores curtos. A classe é definida por gabaritos e provê armazenamento de uma quantidade de valores de um dado tipo fornecido na instanciação do gabarito.

Para ilustrar o uso da classe Vec, são mostrados em seguida, alguns dos tipos predefinidos internamente no OpenCV.

Neste caso, o tipo Vec3b usado no exemplo representa um vetor de três componentes, cada uma do tipo unsigned char, ocupando apenas um byte na memória.

Esse trecho de código usa a função imread() para ler uma imagem presente em um arquivo e armazená-la no objeto image. A função imread() recebe dois parâmetros: o primeiro é o caminho para o arquivo a ser aberto; o segundo é a forma como a imagem será interpretada. Neste casso, independentemente do formato da imagem presente no arquivo bolhas.png, ela será imediatamente transformada em uma imagem em tons de cinza antes de ser guardada no objeto image.

Caso o arquivo não seja aberto (ex: o arquivo não foi encontrado, ou o usuário não possui permissão de leitura ativado), o campo data do objeto image deverá ter valor nulo, sinalizando o erro.

Algo importante a ser observado nesse momento é que, embora a estrutura para armazenamento de imagens seja provida por uma classe - a classe Mat - algumas das estruturas internas são públicas. Isso ajuda a não haver degradação de desempenho com o uso excessivo de chamadas de métodos.

Cria uma janela para que o usuário possa referenciá-la pelo nome que é fornecido. O parâmetro WINDOW_AUTOSIZE permitirá que a janela se ajuste automaticamente para o tamanho da imagen que for fornecida para exibição.

Este trecho de código desenha um retângulo preto na imagem. Neste caso, assumindo que a primeira dimensão representa a coordenada x e a segunda dimensão da matriz representa a coordenada y, será desenhado um retângulo do ponto \$(200,10)\$ até o ponto \$(210,200)\$.

Os pixels da região são acessados ou modificados com o método at. Observe que este método sofre o efeito de um gabarito, que deve receber um tipo correspondente o tipo de dado que está armazenado no objeto image. Como a leitura foi feita assumindo uma imagem em tons de cinza, o tipo de dado necessário será, neste caso, unsigned char. Tipos diferentes poderão gerar resultados incorretos, posto que a função at() interpretará a sequência de bytes da matriz image de forma inapropriada.

Para manter os sistema referencial do tipo destrógiro, assume-se que os eixos x e y ficarão organizados conforme apresenta a Figura 3, com a origem no canto superior esquerdo da imagem.

A imagem image é mostrada na janela "janela" e o programa aguarda até que o usuário digite alguma tecla.

O procedimento que segue repete os passos anteriores, só que agora a imagem interpretada com três componentes de cor. A matriz image agora guardará, para cada pixel, um conjunto de 3 bytes para armazenar as contribuições de vermelho, verde e amarelo que este possui.

As cores em um pixel são ordenadas na sequência B→G→R (Azul, Verde, Vermelho), podendo os pixels da matriz serem interpretados como um conjunto de elementos do tipo Vec3b.

Agora, a função at() interpreta a sequência de bytes usada para armazenar a matriz image como sendo formadas por pixels do tipo Vec3b, sendo às posições correspondentes atribuídas a cor vermelha predefinida na variável val.

A primeira linha usa a classe stringstream para criar um string com o nome do arquivo de saída. O nome do arquivo é formado pela concatenação da string "senoide-" com o valor da constante SIDE e a extensão ".yml". Perceba que é possível alterar o arquivo de saída para se amoldar ao tamanho desejado para o lado da imagem. A segunda linha cria uma matriz de float de tamanho SIDE x SIDE e inicializa todos os elementos com o valor 0. O tipo CV_32FC1 representa um dado em OpenCV de 32 bits em ponto flutuante com apenas um canal (o equivalente ao tipo float). A terceira linha cria um objeto da classe FileStorage para armazenar dados em um arquivo. O primeiro parâmetro é o nome do arquivo de saída, o segundo parâmetro é o modo de abertura do arquivo. Neste caso, o modo de abertura é cv::FileStorage::WRITE, o que indica que o arquivo será aberto para escrita, permitindo a gravação da imagem gerada em ponto flutuante.

O laço aninhado percorre todos os elementos da matriz image e atribui a cada elemento um valor de brilho correspondente à amplitude da senóide naquele ponto. Perceba que na imagem gerada a senóide percorre um total de 8 períodos ao longo de cada linha, o que equivale exatamente ao valor da variável FREQUENCIA. O valor da senoide é multiplicado por 127 e somado a 128 para que o valor da senóide fique entre 0 e 255.

O objeto fs recebe a serialização dos dados da matriz image associados com o identificador literal "mat". Durante o processo de deserialização, o identificador literal "mat" será usado para recuperar os dados da matriz image. O método release() fecha o arquivo de saída. As linhas mostradas na Listagem 5 são extraídas do início do arquivo senoide-256.yml que é gerado pelo programa filestorage.cpp. Perceba que o arquivo codificado em YAML é escrito em texto simples, composto por uma sequência de pares chave-valor, onde a chave é o identificador literal "mat" e o valor é a matriz de float serializada.

A mesma imagem é também gravada no formato PNG, para que possa ser visualizada. Para isso, é necessário converter a matriz de float para o tipo CV_8U, que representa um dado em OpenCV de 8 bits sem sinal com apenas um canal (o equivalente ao tipo unsigned char). O método normalize() é usado para normalizar os valores da matriz de float para o intervalo \$0, 255\$. O método convertTo() converte a matriz de float para o tipo CV_8U para que a gravação no arquivo determinado se dê sem intercorrências. Perceba que a classe stringstream foi novamente usada para proceder com a criação do nome do arquivo. A figura Figura 7 mostra a imagem gerada pelo programa

Esteganografia é uma área da criptologia que se ocupa de ocultar uma informação em outra, de sorte a tornar despercebida uma determinada mensagem. Ela pode ser feita no computador usando arquivos de texto, imagens ou vídeos, de modo que apenas o receptor que conhece como a ocultação foi realizada saiba como recuperar a informação inserida. Na esteganografia, usa-se o princípio da ocultação por obscuridade, onde pressupõe-se que apenas o remetente e o destinatário sabem como decifrar o segredo enviado.

Embora esteja um desuso pelos algoritmos modernos de criptografia, ainda é possível se divertir um pouco com isso, combinando esteganografia com imagens digitais. A ideia é esconder uma imagem secreta einformáticam outra (imagem portadora), mas sem alterar significativamente a aparência da portadora.

Descartando-se uma quantidade de bits menos significativos de cada pixel, suficiente para não perder a qualidade visual da imagem, pode-se usar posições dos bits perdidos para esconder informação. Dá-se a essa prática o nome de esteganografia de bits menos significativos, ou Least Significant Bit steganography.

A ideia é esconder a imagem biel.jpg na imagem sushi.jpg, de modo que a imagem resultante não apresente diferenças significativas em relação à imagem portadora.

Para isso, serão preservados os 5 bits mais significativos (MSB) dos pixels da imagem portadora e os 3 bits mais significativos da imagem escondida serão colocados no lugar dos 3 bits menos significativos (LSB) da imagem portadora, como ilustra a Figura 11. É importante observar que ambas as imagem escondida deve ter no máximo o tamanho da imagem portadora.

Na Listagem 6 que segue é mostrado como esconder o conteúdo de uma imagem em outra utilizando operadores de manipulação de bits com OpenCV.

Para compilar e executar o programa esteg-encode.cpp, salve-o juntamente com os arquivo Makefile e a imagens sushi.jpg biel.jpg em um diretório e execute a seguinte seqüência de comandos:

A primeira linha desse trecho faz com que os N bits menos significativos da imagem portadora sejam anulados, onde N é o número de bits que serão usados para esconder a imagem codificada. A segunda linha faz com que os N bits mais significativos da imagem codificada sejam deslocados à direita para a posição dos N bits menos significativos na variável. A terceira linha faz a combinação dos valores das duas imagens, de modo que os N bits menos significativos da imagem portadora sejam substituídos pelos N bits mais significativos da imagem codificada.

A imagem resultante da esteganografia será gravada no arquivo esteganografia.png. O resultado da esteganografia é mostrado na Figura 12. Observe que a imagem resultante não apresenta diferenças visuais significativas em relação à imagem portadora.

A decomposição em planos de bits da imagem resultante da esteganografia mostra que os bits menos significativos da imagem portadora foram substituídos pelos bits mais significativos da imagem codificada, conforme mostra a Figura 13. A imagem do canto superior esquerdo mostra o plano de bits menos significativo, enquanto a imagem do canto inferior direito mostra o plano de bits mais significativo.

A estrutura Point define um ponto na segunda dimensão que permite acesso às suas coordenadas x e y. Ele será usado no exemplo para indicar a semente de preenchimento que é usada pelo algoritmo floodfill.

Independentemente do formato da imagem de entrada, ela será convertida para tons de cinza, uma vez que o exemplo assume essa condição.

Nesta fase tem início o processo de rotulação das várias regiões da imagem. Assumindo que os pixels do objeto possuem tom de cinza igual a 255, o algoritmo percorre toda a imagem, linha após linha, de cima a baixo, da esquerda para direita por pixels que tenham tom igual a 255.

Quando um elemento da matriz é encontrado com tom de cinza igual a 255, o algoritmo floodfill é executado utilizando as coordenadas desse ponto como semente.

A operação do algoritmo floodfill é bem simples: dado um ponto semente, o algoritmo sai procurando os 4- ou 8-vizinhos desse ponto (conforme configuração estabelecida) que possuem a mesma propriedade do ponto semente (geralmente o tom de cinza). Para cada ponto encontrado, muda-se sua propriedade para uma nova propriedade fornecida. Para cada ponto encontrado, também, realiza-se a busca de vizinhança para os seus 4- ou 8-vizinhos que contenham a mesma propriedade da semente. Esse processo é repetido até que não restem mais pontos com propriedade alterada na componente conectada (ou região conectada).

Inicia a contagem de objetos (inicialmente, zero objetos estão presentes)

A contagem funciona percorrendo as linhas e colunas da matriz image em busca de elementos com tom de cinza igual a 255 (pixel de objeto). Quando encontrado, incrementa-se o contador de objeto e executa-se o algoritmo floodfill na imagem utilizando o pixel encontrado como semente. Observe que a região à qual o pixel pertence será rotulada com tom de cinza igual ao número de contagem de objetos atual.

O processo continua até que toda a imagem tenha sido rotulada.

Finalmente, a imagem image é mostrada (já completamente rotulada) e então gravada no arquivo labeling.png. Uma das linhas com o comando imshow é usada apenas para mostrar a imagem com um pouco de realce (para fins de melhor visualização). Como esse efeito funciona será discutido mais adiante.

Fontes de captura de vídeo são acessadas no OpenCV através da classe VideoCapture. Com ela, o usuário pode abrir um fluxo de vídeo oriundo de um arquivo de vídeo, sequência de imagens ou de um dispositivo de captura. Neste último caso, os dispositivos são identificados por um índice que inicia em 0.

As imagens capturadas nesse exemplo serão extraídas de um fluxo de vídeo que será conectado ao objeto cap.

O cálculo do histograma será realizado para cada uma das componentes de cor de forma independente. Logo, a separação das componentes em matrizes independentes será feita no vetor de matrizes planes. Assim, planes[0], planes[1] e planes[2] armazenarão as componentes de cor Vermelho, Verde e Azul, respectivamente.

As três matrizes histR, histG e histB guardarão os histogramas de suas respectivas componentes de cor.

A variável nbins define o tamanho do vetor utilizado para armazenar os histogramas. O tamanho do histograma não precisa ser necessariamente o mesmo do ton de cinza máximo previsto para uma componente de cor (ex: 256 para imagens RGB). É possível especificar a quantidade de faixas (ou bins) que serão usadas para quantificar as ocorrências dos tons.

No exemplo, usa-se um total de 64 faixas para um tom de cinza máximo igual a 255. No cálculo, portanto, as ocorrências de tom de cinza na faixa \$[0,3\$] serão contabilizadas no primeiro elemento do array com o histograma; as ocorrências na faixa \$[4,7\$] contarão no segundo elemento do histograma, e assim por diante.

É preparada na variável histrange a faixa de valores (mínimo e máximo) presentes na imagem cujo histograma será calculado. Essa variável, da forma como é definida, é usada pela função de cálculo de histograma.

Abre-se a conexão com o primeiro dispositivo de captura de vídeo disponível. Os dispositivos são identificados em sequência. Logo, se um sistema dispõe de duas câmeras, por exemplo, a primeira será associada ao identificador "0" e a segunda ao identificador "1".

Uma vez chamado o método open(), verifica-se se o dispositivo de captura está devidamente conectado para proceder com o restante das tarefas.

Neste exemplo, usamos o método set() para atribuir um tamanho aos quadros capturados pela câmera. A escolha foi feita de modo a fixar um tamanho altura x largura igual a 640x480 pixels. Contudo, é importante observar que as resoluções suportadas são dependentes do dispositivo usado para a captura dos quadros, de sorte que essas duas linhas poderão não surtir efeito em alguns casos.

Finalmente, lê-se a largura (width) e altura(height) dos quadros que serão disponíveis pelo dispositivo. A classe VideoCapture possui diversos métodos para ajustar os parâmetros de captura para o dispositivo conectado. Entretanto, na versão do OpenCV em que foram feitos os testes aqui descritos, alguns podem não funcionar corretamente dependendo do tipo de dispositivo utilizado.

Define-se a largura e altura das imagens que serão usadas para desenhar os histogramas de cada uma das componentes de cor. Note que a altura da imagem é igual à metade da largura para fins de exibição. As imagens são criadas com o tipo CV_8UC3, ou seja, com 8 bits por pixel, com tipo de dados unsigned char contendo 3 canais de cor. A cor, nesse caso, servirá apenas para que o histograma seja desenhado na cor respectiva de sua componente.

Em um loop infinito, as imagens são capturadas, quadro a quadro, do dispositivo de entrada conectado e armazenadas no objeto image. Dispositivos de captura normalmente disponibilizam imagens com suporte a cor, ou seja, cada matriz possui normalmente três planos de cor. Logo, os histogramas deverão ser calculados para cada um desses planos, de modo que a função split() faz a separação adequada para que se proceda com o cálculo.

Histogramas hiperdimensionais que contabilizam as ocorrências das combinações R,G e B dos pixels de uma imagem são possíveis de serem calculados. Entretanto, normalmente são usadas matrizes esparças para isso. Considerando imagens com 8 bits por pixel para cada plano de cor, seria necessário uma matriz com 256 x 256 x 256 elementos para guardar o histograma até mesmo de uma imagem pequena. Esse processo é dispendioso e, normalmente, não possui muita utilidade.

Na análise de histograma, portanto, geralmente se avalia cada componente de cor de forma independente.

Os histogramas são então calculados para cada uma das componentes de cor. A função calcHist() do OpenCV recebe, na sequência, os seguintes argumentos:

Cada histograma é normalizado em uma faixa de valores que vai de 0 até a quantidade de linhas da imagem onde este será desenhado. A normalização é feita linearmente entre os valores máximo e mínimo encontrados na componente de cor.

As imagens com os desenhos dos histogramas são então geradas. Inicialmente, todas são preenchidas com 0 (cor preta). Em seguida, os histogramas são desenhados na forma de um gráfico de barras usando a função line().

Finalmente, as imagens dos histogramas são copiadas, uma abaixo da outra, para o canto superior esquerdo da imagem capturada na câmera.

Os filtros usados no exemplo (determinados pelas matrizes de máscara) são de tamanho \$3 \times 3\$ pixels. Cinco tipos de filtros são testados: média, gaussiano, detector de bordas horizontais, detector de bordas verticais e laplaciano. Os coeficientes de cada filtro são armazenados em arrays unidimensionais que serão repassados ao construtor da matriz do filtro.

Esse trecho de código mostra o procedimento padrão para construção da matriz que será usada como máscara de filtragem. A variável mask recebe uma matriz de tamanho \$3 \times 3\$ em ponto flutuante (CV_32F) com valores iniciais iguais ao do array media que é repassado. Repare que o tipo da matriz precisa ser estabelecido em ponto flutuante, posto que as operações de cálculo contarão com a presença de números fracionários.

Em loop infinito, imagens coloridas são capturadas constantemente na matriz cap e convertidas em equivalentes em tons de cinza usando a função cvtColor(). A imagem então é invertida horizontalmente com a função flip(). A inversão é feita apenas para fins de tornar a interação com o programa exemplo semelhante à de um espelho.

Este trecho é responsável pelo cálculo da filtragem espacial. Cada imagem em tom de cinza armazenada na variável framegray é convertida para outra equivalente com representação em ponto flutuante - frame32f. A conversão é necessária devido aos tipos de operação que serão realizados pela função filter2D(). Observe apenas que OpenCV replica os pixels na borda ('ao invés de preencher de zeros') durante o processo de filtragem.

A função filter2d() recebe então a matriz da imagem em ponto flutuante - frame32f - e produz a matriz frameFiltered, de acordo com o tipo do elemento da matriz de entrada - neste caso, CV_32F (ou float). O objeto Point(1,1) que é repassado como próximo argumento identifica a origem do sistema de coordenadas atribuído para a máscara que, neste caso, é o ponto central da matriz.

Caso a opção de módulo esteja selecionada, o cálculo é então procedido. A imagem filtrada é então convertida para tons de cinza para posterior exibição na tela.

O restante do código trata apenas da adaptação da matriz mask conforme o filtro escolhido pelo usuário para ser aplicado à imagem capturada.

A operação de cálculo da Transformada Discreta de Fourier em OpenCV pode ser realizada pelo seguinte conjunto de passos:

A imagem a ser processada é lida do disco e armazenada na variável image em formato de escala de cinza. Caso a imagem não seja lida com sucesso, o programa finaliza, apresentando uma mensagem de erro. A conversão para escala de cinza é necessária pois o programa foi desenvolvido para processar imagens em escala de cinza.

A função getOptimalDFTSize() identifica os melhores valores com base no tamanho fornecido para acelerar o processo de cálculo da DFT com base em algum algoritmo otimizado. Segundo a documentação do OpenCV, valores múltiplos de dois, três e cinco produzem resultados melhores. Os valores de tamanho ideal para a quantidade de linhas e colunas da imagem são armazenados nas variáveis dft_M e dft_N, respectivamente.

A função copyMakeBorder() cria uma versão da imagem fornecida com uma borda preenchida com zeros e ajustada ao tamanho ótimo para cálculo da DFT, conforme indicado pelo uso da função getOptimalDFTSize(). Para uma imagem image fornecida, a saída é produzida na imagem padded. Caso a imagem fornecida já possua dimensões apropriadas, a imagem de saída será igual à de entrada.

Esse trecho de código prepara a matriz complexa que será fornecida à função de cálculo do dft. Ambas são enfileiradas em um vetor de matrizes e a função merge() se encarrega de produzir a matriz complexa a partir das matrizes presentes no vetor planos.